home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / rpg / crossfir.92 / crossfir / crossfire-0.92.5 / common / readable.c < prev    next >
C/C++ Source or Header  |  1996-07-24  |  27KB  |  859 lines
  1.  
  2. /* This file contains code relevant to the BOOKS hack -- designed
  3.  * to allow randomly occuring messages in non-magical texts.
  4.  */
  5.  
  6. /* laid down initial file - dec 1995. -b.t. thomas@astro.psu.edu */
  7.  
  8. #include <global.h>
  9. #include <read.h>
  10. #include <book.h>
  11. #include <living.h>
  12. #include <spells.h>
  13.  
  14. /* This flag is useful to see what kind of output messages are created */
  15.  
  16. /* #define BOOK_MSG_DEBUG */ 
  17.  
  18.  
  19. /* init_readable() - initialize linked lists utilized by 
  20.  * message functions in tailor_readable_ob() */
  21.  
  22. void init_readable( void ) {
  23.   static int did_this;
  24.  
  25.   if(!did_this) did_this=1; 
  26.   else return;
  27.  
  28.   fprintf(logfile,"\nInitializing reading data...");
  29.   init_msgfile();
  30.   init_mon_info();
  31.  
  32. }
  33.  
  34. /* tailor_readable_ob()- The main routine. This chooses a random 
  35.  * message to put in given readable object (type==BOOK) which will 
  36.  * be referred hereafter as a 'book'. We use the book level to de- 
  37.  * termine the value of the information we will insert. Higher 
  38.  * values mean the book will (generally) have better/more info. 
  39.  * See individual cases as to how this will be utilized.
  40.  * "Book" name/content length are based on the weight of the 
  41.  * document. If the value of msg_type is negative, we will randomly
  42.  * choose the kind of message to generate. 
  43.  * -b.t. thomas@astro.psu.edu
  44.  */
  45.  
  46. void tailor_readable_ob (object *book, int msg_type) {
  47.   char msgbuf[BOOK_BUF];
  48.   int level=book->level?(RANDOM()%book->level)+1:1;
  49.   int book_buf_size;
  50.   
  51.   /* safety */
  52.   if(book->type!=BOOK) return;
  53.  
  54.   /* lets give the "book" a new name, which may be a compound word */
  55.   change_book_name(book);
  56.  
  57.   if(level<=0) return; /* if no level no point in doing any more... */
  58.  
  59.   book_buf_size = BOOKSIZE(book);
  60.  
  61.     /* ...but lets not exceed the actual max buffer!... */
  62.   if(book_buf_size>BOOK_BUF) book_buf_size = BOOK_BUF;
  63.  
  64.    /* &&& The message switch &&& */
  65.    /* Below all of the possible types of messages in the "book"s.
  66.     * if you add another case, make sure all are reachable by the 
  67.     * random number generator */
  68.  
  69.   switch(msg_type>0?msg_type:(RANDOM()%6+1)) {
  70.         case 1: /* monster attrib */
  71.           strcpy(msgbuf, mon_info_msg(level,book_buf_size));
  72.           break;
  73.         case 2: /* artifact attrib */
  74.           strcpy(msgbuf, artifact_msg(level,book_buf_size));
  75.           break;
  76.         case 3: /* grouping spells/prayers by path */
  77.           strcpy(msgbuf, spellpath_msg(level,book_buf_size));
  78.           break;
  79.         case 4: /* describe an alchemy formula */
  80. #ifdef ALCHEMY
  81.           strcpy(msgbuf, formula_msg(level,book_buf_size));
  82. #else
  83.           strcpy(msgbuf, msgfile_msg(level,book_buf_size));
  84. #endif
  85.           break;
  86.         case 5: /* bits of information about a god */
  87. #ifdef MULTIPLE_GODS 
  88.           strcpy(msgbuf, god_info_msg(level,book_buf_size));
  89. #else
  90.           strcpy(msgbuf, msgfile_msg(level,book_buf_size));
  91. #endif 
  92.           break;
  93.         case 6: /* use info list in lib/ */
  94.         default:
  95.           strcpy(msgbuf, msgfile_msg(level,book_buf_size));
  96.           break;
  97.   }
  98.  
  99.   strcat(msgbuf,"\n"); /* safety -- we get ugly map saves/crashes w/o this */ 
  100.   if(strlen(msgbuf)>1) {
  101.       if(book->msg) free_string(book->msg);
  102.     book->msg=add_string(msgbuf);
  103.   }
  104. }
  105.  
  106. /* change_book_name() - give a new, fancier name to generated 
  107.  * objects of type BOOK and SPELLBOOK.
  108.  */
  109.  
  110. void change_book_name (object *book) {
  111.   int nbr = sizeof(book_descrpt)/sizeof(char *);
  112.   char name[MAX_BUF];
  113.  
  114.  /* build up a new name buffer in 2 steps */
  115.  
  116.    /* first the name of the book. */
  117.   switch(book->type) {
  118.      case BOOK:  /* Name based on weight */
  119.         if(book->weight>2000) {
  120.            nbr = sizeof(heavy_book_name)/sizeof(char *);
  121.            strcpy(name,heavy_book_name[RANDOM()%nbr]);
  122.         } else if(book->weight<2001) {
  123.            nbr = sizeof(light_book_name)/sizeof(char *);
  124.            strcpy(name,light_book_name[RANDOM()%nbr]);
  125.         }
  126.         /* lets give the book an author */
  127.         if(!book->title&&(strlen(name)<20)&&!(RANDOM()%2))
  128.           add_author(book);
  129.     break;
  130.       case SPELLBOOK: /* depends on mage/clerical */
  131.     if(!strcmp(book->arch->name,"cleric_book")) { 
  132.            nbr = sizeof(priest_book_name)/sizeof(char *);
  133.            strcpy(name,priest_book_name[RANDOM()%nbr]);
  134.     } else {
  135.            nbr = sizeof(mage_book_name)/sizeof(char *);
  136.            strcpy(name,mage_book_name[RANDOM()%nbr]);
  137.     }
  138.         break;
  139.       default:
  140.         LOG(llevError,"change_book_name() called w/ illegal obj type.\n"); 
  141.     return;
  142.   }
  143.  
  144.    /* second, sometimes we give a book description */
  145.   if(!RANDOM()%3) sprintf(name,"%s %s",book_descrpt[RANDOM()%nbr],name);
  146.  
  147.   if(book->name) free_string(book->name);
  148.   book->name = add_string(name);
  149.   
  150. }
  151.  
  152. /* add_book_author() */
  153.  
  154. void add_author (object *op) {
  155.   char name[MAX_BUF];
  156.   int nbr = sizeof(book_author)/sizeof(char *); 
  157.  
  158.   sprintf(name,"of %s",book_author[RANDOM()%nbr]);
  159.   op->title=add_string(name);
  160. }
  161.  
  162. /* msgfile_msg() - generate a message drawn randomly from a 
  163.  * file in lib/. Level currently has no effect on the message
  164.  * which is returned. 
  165.  */
  166.  
  167. char * msgfile_msg (int level, int booksize) {
  168.   static char retbuf[BOOK_BUF];
  169.   int i,msgnum;
  170.   linked_char *msg=NULL;
  171.  
  172.     /* get a random message for the 'book' from linked list */
  173.   if(nrofmsg>1) {
  174.      msg = first_msg;
  175.      msgnum=RANDOM()%nrofmsg; 
  176.      for(i=0;msg&&i<nrofmsg&&i!=msgnum;i++)
  177.     msg=msg->next; 
  178.   }
  179.  
  180.   if(msg&&!book_overflow(retbuf,msg->name,booksize)) 
  181.      strcpy(retbuf,msg->name);
  182.   else 
  183.      sprintf(retbuf,"\n <undecipherable text>");
  184.  
  185. #ifdef BOOK_MSG_DEBUG
  186.   LOG(llevDebug,"\n info_list_msg() created strng: %d\n",strlen(retbuf));
  187.   fprintf(logfile," MADE THIS:\n%s\n",retbuf);
  188. #endif
  189.  
  190.   return retbuf;
  191. }
  192.  
  193. /* init_msgfile() - if not called before, initialize the info list */
  194.  
  195. void init_msgfile ( void ) {
  196.   FILE *fp;
  197.   char buf[MAX_BUF], msgbuf[HUGE_BUF], fname[MAX_BUF], *cp;
  198.   int comp;
  199.   static int did_init_msgfile;
  200.  
  201.   if(did_init_msgfile) return;
  202.   did_init_msgfile=1;
  203.  
  204.   sprintf(fname, "%s/messages", LibDir);
  205.  
  206.   if ((fp = open_and_uncompress(fname, 0, &comp)) != NULL) { 
  207.      linked_char *tmp=NULL;
  208.      while (fgets(buf, MAX_BUF, fp)!=NULL) {
  209.         if (*buf=='#') continue; 
  210.         if((cp=strchr(buf,'\n'))!=NULL) *cp='\0';
  211.         cp=buf;
  212.         while(*cp==' ') /* Skip blanks */
  213.           cp++;
  214.         if(!strncmp(cp, "ENDMSG", 6)) {
  215.         if(strlen(msgbuf)>BOOK_BUF) {
  216.         LOG(llevDebug,"Warning: this string exceeded max book buf size:");
  217.         LOG(llevDebug,"  %s",msgbuf);
  218.         }
  219.             tmp->name = add_string(msgbuf);
  220.             tmp->next = first_msg;
  221.             first_msg = tmp;
  222.             nrofmsg++; continue;
  223.         }
  224.     else if(!strncmp(cp, "MSG", 3)) { 
  225.             tmp = (linked_char*) malloc(sizeof(linked_char));
  226.         strcpy(msgbuf," "); /* reset msgbuf for new message */ 
  227.         continue;
  228.         } else if(!buf_overflow(msgbuf,cp,HUGE_BUF-1)) { 
  229.         strcat(msgbuf,cp); strcat(msgbuf,"\n");
  230.     }
  231.      }   
  232.      close_and_delete(fp, comp);
  233.   }
  234.  
  235. #ifdef BOOK_MSG_DEBUG
  236.     LOG(llevDebug,"\ninit_info_listfile() got %d messages.\n",nrofmsg);
  237. #endif    
  238. } 
  239.  
  240. #ifdef ALCHEMY
  241.  
  242. /* formula_msg() - generate a message detailing the properties
  243.  * of a randomly selected alchemical formula.
  244.  */
  245.  
  246. char * formula_msg (int level, int booksize) {
  247.   static char retbuf[BOOK_BUF];
  248.   recipelist *fl;
  249.   recipe *formula=NULL;
  250.   int chance;
  251.   
  252.   /* the higher the book level, the more complex (ie number of
  253.    * ingredients) the formula can be. 
  254.    */
  255.   fl = get_formulalist(((RANDOM()%level)/3)+1);
  256.  
  257.   if(!fl) fl=get_formulalist(1); /* safety */
  258.     
  259.   if(fl->total_chance==0) { 
  260.       strcpy(retbuf,"\n <undecipherable message> \n");
  261.     return retbuf; 
  262.   } 
  263.  
  264.   /* get a random formula, weighted by its bookchance */
  265.   chance = RANDOM()%fl->total_chance;
  266.   for(formula=fl->items;formula!=NULL;formula=formula->next) { 
  267.     chance -= formula->chance;
  268.     if(chance<=0) break;
  269.   } 
  270.  
  271.   /* preamble */
  272.   strcpy(retbuf,"Herein is described an alchemical proceedure: \n");
  273.  
  274.    /* looks like a formula was found. Base the amount
  275.     * of information on the booklevel and the spellevel
  276.     * of the formula. */ 
  277.   if(formula) { 
  278.       char *op_name=NULL;
  279.     archetype *at;
  280.     int nindex=nstrtok(formula->arch_name,",");
  281.  
  282.     /* construct name of object to be made*/
  283.     if(nindex>1) {
  284.        int rnum = RANDOM()%nindex;
  285.            op_name = strtok(formula->arch_name,",");  
  286.        while(rnum) { op_name = strtok(NULL,","); rnum--; }
  287.     } else 
  288.        op_name = formula->arch_name;  
  289.     if((at=find_archetype(op_name))!=(archetype *)NULL)
  290.        op_name = at->clone.name;
  291.     else 
  292.        LOG(llevError,"formula_msg() can't find arch %s for formula.",
  293.          op_name); 
  294.     /* item name */
  295.     if(strcmp(formula->title,"NONE"))
  296.        sprintf(retbuf,"%sThe %s of %s",retbuf,op_name,formula->title);
  297.     else {
  298.        sprintf(retbuf,"%sThe %s",retbuf,op_name);
  299.       if(at->clone.title) {
  300.           strcat(retbuf," ");
  301.           strcat(retbuf,at->clone.title);
  302.       }
  303.         }
  304.       /* ingredients to make it */
  305.         if (formula->ingred !=NULL) {
  306.          linked_char *next;
  307.        strcat(retbuf," may be made using the \nfollowing ingredients:\n");
  308.            for (next=formula->ingred; next!=NULL; next=next->next) { 
  309.                   strcat(retbuf,next->name); strcat(retbuf,"\n");
  310.        }
  311.         } else  
  312.        LOG(llevError,"formula_msg() no ingredient list for object %s of %s",
  313.          op_name,formula->title);
  314.   } else
  315.     strcat(retbuf," <indescipherable text>\n");
  316.  
  317. #ifdef BOOK_MSG_DEBUG
  318.   LOG(llevDebug,"\n formula_msg() created strng: %d\n",strlen(retbuf));
  319.   fprintf(logfile," MADE THIS:\n%s\n",retbuf);
  320. #endif
  321.  
  322.   return retbuf;
  323. }
  324. #endif
  325.  
  326. /* mon_info_msg() - generate a message detailing the properties 
  327.  * of a randomly selected monster.
  328.  */
  329.  
  330. char * mon_info_msg (int level, int booksize) {
  331.   static char retbuf[BOOK_BUF];
  332.   char tmpbuf[HUGE_BUF];
  333.   object *tmp;
  334.  
  335.   /*preamble */
  336.   strcpy(retbuf,"This beastuary contains:");
  337.  
  338.   /* lets print info on as many monsters as will fit in our 
  339.    * document. 
  340.    */
  341.   while((tmp=get_random_mon(level*3))!=NULL) { 
  342.  
  343.       /* monster description */
  344.       sprintf(tmpbuf,"\n---\n%s",mon_desc(tmp));
  345.  
  346.       if(!book_overflow(retbuf,tmpbuf,booksize)) 
  347.             strcat(retbuf,tmpbuf);
  348.       else break;
  349.   }
  350.  
  351. #ifdef BOOK_MSG_DEBUG
  352.   LOG(llevDebug,"\n mon_info_msg() created strng: %d\n",strlen(retbuf));
  353.   fprintf(logfile," MADE THIS:\n%s\n",retbuf);
  354. #endif
  355.  
  356.   return retbuf;
  357. }
  358.  
  359. char * mon_desc ( object *mon ) {
  360.   static char retbuf[HUGE_BUF];
  361.  
  362.   sprintf(retbuf," *** %s ***\n",mon->name);
  363.   strcat(retbuf,describe_item(mon));
  364.  
  365.   return retbuf;
  366. }
  367.  
  368. /* get_random_mon() - returns a random monster slected from linked 
  369.  * list of all monsters in the current game. If level is non-zero,
  370.  * then only monsters greater than that level will be returned.
  371.  */ 
  372.  
  373. object *get_random_mon ( int level ) {
  374.   objectlink *mon=first_mon_info;
  375.   int i=0,monnr;
  376.  
  377.   /* safety check.  Problem w/ init_mon_info list? */
  378.   if(!nrofmon||!mon) return (object *) NULL; 
  379.  
  380.   /* lets get a random monster from the mon_info linked list */
  381.   monnr = RANDOM()%nrofmon;
  382.   do {
  383.     mon = mon->next;
  384.     i++;
  385.   } while (i<monnr);
  386.  
  387.   /* now, we only print info on monsters w/ appropriate level */ 
  388.   if(level>0) {
  389.      int passed_once = 0;
  390.      while (mon->ob->level>level) 
  391.         if(mon->next) 
  392.           mon = mon->next; 
  393.         else if(!passed_once) { 
  394.           mon = first_mon_info; 
  395.       passed_once = 1;
  396.     } else {
  397.       LOG(llevError,"get_random_mon() couldnt return monster for level %d\n",
  398.         level);
  399.       return (object *) NULL;
  400.     } 
  401.   }
  402.  
  403.   return mon->ob;
  404. }
  405.  
  406. /* init_mon_info() - creates the linked list of pointers to 
  407.  * monster archetype objects if not called previously
  408.  */ 
  409.  
  410. void init_mon_info ( void ) {
  411.   archetype *at;
  412.   static int did_init_mon_info;
  413.  
  414.   if(!did_init_mon_info) did_init_mon_info=1;
  415.   else return;
  416.  
  417.   for(at=first_archetype;at!=NULL;at=at->next) {
  418.     if (QUERY_FLAG(&at->clone,FLAG_MONSTER)&&
  419.      (!QUERY_FLAG(&at->clone,FLAG_CHANGING)
  420.        ||QUERY_FLAG(&at->clone,FLAG_UNAGGRESSIVE))
  421.     ) {
  422.       objectlink *mon = (objectlink *) malloc(sizeof(objectlink));
  423.  
  424.     mon->ob = &at->clone;
  425.     mon->id = nrofmon;
  426.     if(first_mon_info)
  427.        mon->next = first_mon_info;
  428.     first_mon_info = mon;
  429.     nrofmon++;
  430.     }
  431.   }
  432.   LOG(llevDebug,"init_mon_info() got %d monsters\n",nrofmon);
  433. }
  434.  
  435. /* spellpath_msg() - generate a message detailing the member
  436.  * spells/prayers (and some of their properties) belonging to 
  437.  * a given spellpath. 
  438.  */ 
  439.  
  440. char * spellpath_msg (int level, int booksize) {
  441.   static char retbuf[BOOK_BUF];
  442.   char tmpbuf[BOOK_BUF];
  443.   int path=(RANDOM()%(NRSPELLPATHS+1)-1),prayers=RANDOM()%2;
  444.   int i=0,did_first_sp=0;  
  445.   uint32 pnum = (path==-1) ? PATH_NULL : spellpathdef[path];
  446.  
  447.   /* Preamble */
  448.   sprintf(retbuf,"Herein are detailed the names of %s\n",
  449.     !(prayers) ? "spells" : "prayers");
  450.   if(path==-1) 
  451.         strcat(retbuf,"having no known spell path.\n");
  452.   else    
  453.         sprintf(retbuf,"%sbelonging to the path of %s:\n",retbuf,
  454.         spellpathnames[path]);
  455.  
  456.   /* Now go through the entire list of spells. Add appropriate spells
  457.    * in our message buffer */
  458.  
  459.   do {
  460.     if((spells[i].books||prayers)&&spells[i].cleric==prayers
  461.     &&(pnum&spells[i].path)) {
  462.       /* book level determines max spell level to show 
  463.        * thus higher level books are more comprehensive */ 
  464.       if(spells[i].level>(level*3)) {
  465.          i++;
  466.          continue; 
  467.       }
  468.       strcpy(tmpbuf,spells[i].name);
  469.  
  470.       if(book_overflow(retbuf,tmpbuf,booksize))
  471.          break;
  472.       else { 
  473.              if(did_first_sp) strcat(retbuf,",\n");
  474.          did_first_sp=1;
  475.              strcat(retbuf,tmpbuf);
  476.       }
  477.     }
  478.     i++;
  479.   } while(i<NROFREALSPELLS);
  480.  
  481.   /* Geez, no spells were generated. */
  482.   if(!did_first_sp) 
  483.     if(RANDOM()%4) /* usually, lets make a recursive call... */
  484.        sprintf(retbuf, spellpath_msg(level,booksize));
  485.     else /* give up, cause knowning no spells exist for path is info too. */
  486.        strcat(retbuf,"\n - no known spells exist -\n");
  487.   else { 
  488. #ifdef BOOK_MSG_DEBUG
  489.      LOG(llevDebug,"\n spellpath_msg() created strng: %d\n",strlen(retbuf));
  490.      fprintf(logfile," MADE THIS: path=%d pray=%d\n%s\n",path,prayers,retbuf);
  491. #endif
  492.      strcat(retbuf,"\n");
  493.   }
  494.   return retbuf;
  495. }
  496.  
  497. /* artifact_msg() - generate a message detailing the properties
  498.  * of 1-6 artifacts drawn sequentially from the artifact list.
  499.  */
  500.  
  501. char *artifact_msg (int level, int booksize) {
  502.   artifactlist *al=NULL;
  503.   artifact *art;
  504.   int chance,i,type,index;
  505.   int book_entries=level>5?RANDOM()%3+RANDOM()%3+2:RANDOM()%level+1;
  506.   char *ch, name[MAX_BUF],buf[BOOK_BUF],sbuf[MAX_BUF];
  507.   static char retbuf[BOOK_BUF];
  508.   object *tmp=NULL;
  509.  
  510.   /* values greater than 5 create msg buffers that are too big! */
  511.   if(book_entries>5) book_entries=5;
  512.  
  513.   /* lets determine what kind of artifact type randomly.
  514.    * Right now legal artifacts only come from those listed
  515.    * in art_name_array. Also, we check to be sure an artifactlist
  516.    * for that type exists!
  517.    */
  518.   do {
  519.      index = RANDOM()%(sizeof(art_name_array)/sizeof(arttypename));
  520.      type=art_name_array[index].type;
  521.      al = find_artifactlist(type);
  522.   } while(al==NULL);
  523.  
  524.   /* There is no reason to start on the artifact list at the begining. Lets
  525.    * take our starting position randomly... */
  526.   art=al->items;
  527.   for(i=RANDOM()%level+RANDOM()%2+1;i>0;i--) {
  528.         if(art==NULL) art=al->items; /* hmm, out of stuff, loop back around */
  529.         art=art->next;
  530.   }
  531.  
  532.   /* the base 'generic' name for our artifact */
  533.   sprintf(name,art_name_array[index].name);
  534.  
  535.   /* Ok, lets print out the contents */
  536.   sprintf(retbuf,"Herein %s detailed %s...\n",book_entries>1?"are":"is",
  537.         book_entries>1?"some artifacts":"an artifact");
  538.  
  539.   /* artifact msg attributes loop. Lets keep adding entries to the 'book'
  540.    * as long as we have space up to the allowed max # (book_entires) 
  541.    */
  542.   while(book_entries>0){
  543.  
  544.     if(art==NULL) art=al->items;
  545.  
  546.     /* separator of items */
  547.     strcpy(buf,"--- \n");
  548.  
  549.     /* Name */
  550.     if (art->allowed!=NULL&&strcmp(art->allowed->name,"All")) {
  551.         linked_char *temp,*next=art->allowed;
  552.         do {
  553.           temp=next;
  554.           next=next->next;
  555.         } while ((next!=(linked_char *) NULL)&&!RANDOM()%2);
  556.         sprintf(buf,"%s A %s of %s",buf,temp->name,art->item->name);
  557.     }
  558.     else /* default name is used */
  559.         sprintf(buf,"%s The %s of %s",buf,name,art->item->name);
  560.  
  561.     /* chance of finding */
  562.     chance = 100 * ((float) art->chance/al->total_chance);
  563.     if(chance>=20) sprintf(sbuf,"an uncommon");
  564.     else if(chance>=10) sprintf(sbuf,"an unusual");
  565.     else if(chance>=5) sprintf(sbuf,"a rare");
  566.     else sprintf(sbuf,"a very rare");
  567.     sprintf(buf,"%s is %s\n",buf,sbuf);
  568.  
  569.     /* value of artifact */
  570.     sprintf(buf,"%s item with a value that is %d times normal.\n",
  571.         buf,art->item->value);
  572.  
  573.     /* include the message about the artifact, if exists, and book
  574.      * level is kinda high */
  575.     if(art->item->msg&&(RANDOM()%4+1)<level&&
  576.         !((strlen(art->item->msg)+strlen(buf))>BOOK_BUF))
  577.           sprintf(buf,"%s %s",buf,art->item->msg);
  578.  
  579.     /* properties of the artifact */
  580.     tmp=get_object();
  581.     add_abilities(tmp,art->item);
  582.     tmp->type = type;
  583.     SET_FLAG(tmp,FLAG_IDENTIFIED);
  584.     if((ch=describe_item(tmp))!=NULL&&strlen(ch)>1)
  585.         sprintf(buf,"%s Properties of this artifact include: \n %s \n",
  586.             buf,ch);
  587.  
  588.     /* add the buf if it will fit */
  589.     if(!book_overflow(retbuf,buf,booksize)) 
  590.            strcat(retbuf,buf);
  591.     else break; 
  592.  
  593.     art=art->next;
  594.     book_entries--;
  595.   }
  596.     
  597. #ifdef BOOK_MSG_DEBUG
  598.   LOG(llevDebug,"artifact_msg() created strng: %d\n",strlen(retbuf));
  599.   fprintf(logfile," MADE THIS:\n%s",retbuf);
  600. #endif
  601.   return retbuf;
  602. }   
  603.  
  604. /* arttype_has_name() returns the array value if the artifact is
  605.  * listed in art_name_array */
  606.  
  607. int arttype_has_name (int value) {
  608.   int i,number=sizeof(art_name_array)/sizeof(arttypename);
  609.  
  610.   for(i=0;i<number;i++)
  611.         if(art_name_array[i].type==value) return i;
  612.  
  613.   return -1;
  614. }
  615.  
  616. /* god_info_msg() - generate a message detailing the properties
  617.  * of a random god. Used by the book hack. b.t.
  618.  */
  619.  
  620. char *god_info_msg (int level, int booksize) {
  621.   static char retbuf[BOOK_BUF];
  622.   char *name=NULL, buf[BOOK_BUF];
  623.   int i,introlen;
  624.   int godnr=RANDOM()%NROFGODS; /* get a random god to 'profile' */
  625.  
  626.   name=Gods[godnr].name;
  627.   if(name==NULL) return (char *) NULL; /* oops, problems...*/
  628.  
  629.   /* preamble..*/
  630.   sprintf(retbuf,"This document contains knowledge concerning\n");
  631.   sprintf(retbuf,"%sthe diety %s",retbuf,name);
  632.  
  633.   /* Always have as default information the god's descriptive terms. */
  634.   if(nstrtok(Gods[godnr].desc,",")>0) {
  635.      strcat(retbuf,", known as");
  636.      strcat(retbuf,strtoktolin(Gods[godnr].desc,","));
  637.   } else
  638.      strcat(retbuf,"...");
  639.  
  640.   strcat(retbuf,"\n ---\n");
  641.   introlen = strlen(retbuf); /* so we will know if no new info is added later */
  642.  
  643.   /* Information about the god is random, and based on the level of the
  644.    * 'book'. Probably there is a more intellegent way to implement
  645.    * this ...
  646.    */
  647.  
  648.   while(level>0) {
  649.         sprintf(buf," ");
  650.         if(level==2&&RANDOM()%2) { /* enemy god */
  651.             char *enemy=Gods[godnr].enemy;
  652.             if(enemy) sprintf(buf,"The gods %s and %s are enemies.\n ---\n",
  653.                 name,enemy);
  654.         }
  655.         if(level==3&&RANDOM()%2) { /* enemy race, what the god's holy word effects */
  656.             char *enemy=Gods[godnr].enemy_race;
  657.             if(enemy&&!(Gods[godnr].path_denied&PATH_TURNING))
  658.                if((i=nstrtok(enemy,","))>0) {
  659.                     char tmpbuf[MAX_BUF];
  660.                     sprintf(buf,"The holy words of %s have the power to\n",name);
  661.                     strcat(buf,"slay creatures belonging to the ");
  662.                     if(i>1)
  663.                         sprintf(tmpbuf,"following \n races:%s",
  664.                           strtoktolin(enemy,","));
  665.                     else
  666.                         sprintf(tmpbuf,"race of%s",strtoktolin(enemy,","));
  667.                     sprintf(buf,"%s%s\n ---\n",buf,tmpbuf);
  668.                }
  669.         }
  670.         if(level==4&&RANDOM()%2) { /* Priest of god gets these protect,vulnerable... */
  671.                 int has_effect=0,tmpvar;
  672.                 char tmpbuf[MAX_BUF];
  673.                 sprintf(tmpbuf,"%s has a potent aura which is extended\n"
  674.                         ,name);
  675.                 strcat(tmpbuf,"faithful priests. The effects of this aura include:\n");
  676.                 if((tmpvar=Gods[godnr].protected)) {
  677.                         has_effect = 1;
  678.                         DESCRIBE_ABILITY(tmpbuf, tmpvar, "Protected");
  679.                 }
  680.                 if(strlen(tmpbuf)>38) sprintf(tmpbuf,"%s\n",tmpbuf);
  681.                 if((tmpvar=Gods[godnr].vulnerable)) {
  682.                         has_effect = 1;
  683.                         DESCRIBE_ABILITY(tmpbuf, tmpvar, "Vulnerable");
  684.                 }
  685.                 if(has_effect) {
  686.                         strcat(buf,tmpbuf);
  687.                         strcat(buf,"\n ---\n");
  688.                 } else
  689.                         sprintf(buf," ");
  690.         }
  691.         if(level==5&&RANDOM()%2) { /* aligned race, summoning  */
  692.             char *race=Gods[godnr].aligned_race;
  693.             if(race&&!(Gods[godnr].path_denied&PATH_SUMMON))
  694.                if((i=nstrtok(race,","))>0) {
  695.                     char tmpbuf[MAX_BUF];
  696.                     sprintf(buf,"Creatures sacred to %s include the \n",name);
  697.                     if(i>1)
  698.                         sprintf(tmpbuf,"following \n races:%s",
  699.                           strtoktolin(race,","));
  700.                     else
  701.                         sprintf(tmpbuf,"race of%s",strtoktolin(race,","));
  702.                     sprintf(buf,"%s%s\n ---\n",buf,tmpbuf);
  703.                }
  704.         }
  705.         if(level==6&&RANDOM()%2) { /* blessing,curse properties of the god */
  706.                 int has_effect=0,tmpvar;
  707.                 char tmpbuf[MAX_BUF];
  708.                 sprintf(tmpbuf,"\n");
  709.                 sprintf(tmpbuf,"The priests of %s are known to be able to \n"
  710.                         ,name);
  711.                 if((tmpvar=Gods[godnr].protected)) {
  712.                         has_effect = 1;
  713.                         strcat(tmpbuf,"bestow a blessing which makes the recipient\n");
  714.                         DESCRIBE_ABILITY(tmpbuf, tmpvar, "Protected");
  715.                 }
  716.                 if((tmpvar=Gods[godnr].vulnerable)) {
  717.                         strcat(tmpbuf,"\n");
  718.                         if(has_effect) strcat(tmpbuf,"and ");
  719.                         else has_effect = 1;
  720.                         strcat(tmpbuf,"lay a curse which makes the recipient\n");
  721.                         DESCRIBE_ABILITY(tmpbuf, tmpvar, "Vulnerable");
  722.                 }
  723.                 if(has_effect) {
  724.                         strcat(buf,tmpbuf);
  725.                         strcat(buf,"\n ---\n");
  726.                 } else
  727.                         sprintf(buf," ");
  728.         }
  729.         if(level==8&&RANDOM()%2) {  /* immunity, holy possession */
  730.                 int has_effect=0,tmpvar;
  731.                 char tmpbuf[MAX_BUF];
  732.                 sprintf(tmpbuf,"\n");
  733.                 sprintf(tmpbuf,"The priests of %s are known to make cast a mighty \n"
  734.                         ,name);
  735.                 if((tmpvar=Gods[godnr].immune)) {
  736.                         has_effect = 1;
  737.                         strcat(tmpbuf,"prayer of possession which gives the recipient\n");
  738.                         DESCRIBE_ABILITY(tmpbuf, tmpvar, "Immunity");
  739.                 }
  740.                 if(has_effect) {
  741.                         strcat(buf,tmpbuf);
  742.                         strcat(buf,"\n ---\n");
  743.                 } else
  744.                         sprintf(buf," ");
  745.         }
  746.         if(level==12&&RANDOM()%2) { /* spell paths */
  747.                 int has_effect=0,tmpvar;
  748.                 char tmpbuf[MAX_BUF];
  749.                 sprintf(tmpbuf,"\n");
  750.                 sprintf(tmpbuf,"It is rarely known fact that the priests of %s\n"
  751.                         ,name);
  752.                 strcat(tmpbuf,"are mystically transformed. Effects of this include:\n");                if((tmpvar=Gods[godnr].path_attuned)) {
  753.                         has_effect = 1;
  754.                         DESCRIBE_PATH(tmpbuf, tmpvar, "Attuned");
  755.                 }
  756.                 if((tmpvar=Gods[godnr].path_repelled)) {
  757.                         has_effect = 1;
  758.                         DESCRIBE_PATH(tmpbuf, tmpvar, "Repelled");
  759.                 }
  760.                 if((tmpvar=Gods[godnr].path_denied)) {
  761.                         has_effect = 1;
  762.                         DESCRIBE_PATH(tmpbuf, tmpvar, "Denied");
  763.                 }
  764.                 if(has_effect) {
  765.                         strcat(buf,tmpbuf);
  766.                         strcat(buf,"\n ---\n");
  767.                 } else
  768.                         sprintf(buf," ");
  769.         }
  770.  
  771.         /* check to be sure new buffer size dont exceed either
  772.          * the maximum buffer size, or the 'natural' size of the
  773.          * book...
  774.          */
  775.     if(book_overflow(retbuf,buf,booksize)) 
  776.         break;
  777.         else if(strlen(buf)>1) strcat(retbuf,buf);
  778.         level--;
  779.   }
  780.   if(strlen(retbuf)==introlen) { /* we got no information beyond the preamble! */
  781.         strcat(retbuf," [Unfortunately the rest of the information is\n");
  782.         strcat(retbuf,"  hopelessly garbled!]\n ---\n");
  783.   }
  784. #ifdef BOOK_MSG_DEBUG
  785.   LOG(llevDebug,"\n god_info_msg() created strng: %d\n",strlen(retbuf));
  786.   fprintf(logfile," MADE THIS:\n%s",retbuf);
  787. #endif
  788.   return retbuf;
  789. }
  790.  
  791. int book_overflow(char *buf1, char *buf2, int booksize) {
  792.  
  793.   if( buf_overflow(buf1,buf2,BOOK_BUF-2) /* 2 less so always room for trailing \n */ 
  794.      || buf_overflow(buf1,buf2,booksize))
  795.     return 1;
  796.   return 0;
  797. }
  798.  
  799. /* HANDMADE STRING FUNCTIONS.., perhaps these belong in another file 
  800.  * (shstr.c ?), but the quantity BOOK_BUF will need to be defined. */
  801.  
  802. /* buf_overflow() - we don't want to exceed the buffer size of 
  803.  * buf1 by adding on buf2! Returns true if overflow will occur.
  804.  */
  805.  
  806. int buf_overflow(char *buf1, char *buf2, int bufsize) {
  807.   int len1=0,len2=0;
  808.   
  809.   if(buf1) len1=strlen(buf1); 
  810.   if(buf2) len2=strlen(buf2); 
  811.   if((len1+len2)>=bufsize) return 1;
  812.   return 0;
  813. }
  814.  
  815. /* nstrtok() - simple routine to return the number of list
  816.  * items in buf1 as separated by the value of buf2
  817.  */
  818.  
  819. int nstrtok (char *buf1, char *buf2) {
  820.   char *tbuf,sbuf[12],buf[MAX_BUF];
  821.   int number=0;
  822.  
  823.   if(!buf1||!buf2) return 0;
  824.   sprintf(buf,"%s",buf1);
  825.   sprintf(sbuf,"%s",buf2);
  826.   tbuf=strtok(buf,sbuf);
  827.   while(tbuf) {
  828.        number++;
  829.        tbuf = strtok(NULL,sbuf);
  830.   }
  831.   return number;
  832. }
  833.  
  834. /* strtoktolin() - takes a string in buf1 and separates it into
  835.  * a list of strings delimited by buf2. Then returns a comma
  836.  * separated string w/ decent punctuation.
  837.  */
  838.  
  839. char *strtoktolin (char *buf1, char *buf2) {
  840.   int maxi, i = nstrtok(buf1,buf2);
  841.   char *tbuf, buf[MAX_BUF], sbuf[12];
  842.   static char rbuf[BOOK_BUF];
  843.  
  844.   maxi = i;
  845.   sprintf(buf,"%s",buf1);
  846.   sprintf(sbuf,"%s",buf2);
  847.   sprintf(rbuf," ");
  848.   tbuf = strtok(buf,sbuf);
  849.   while(tbuf&&i>0) {
  850.         strcat(rbuf,tbuf);
  851.         i--;
  852.         if(i==1&&maxi>1) strcat(rbuf," and ");
  853.         else if(i>0&&maxi>1) strcat(rbuf,", ");
  854.         else strcat(rbuf,".");
  855.         tbuf = strtok(NULL,sbuf);
  856.   }
  857.   return (char *) rbuf;
  858. }
  859.